home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / MM2_DEV / S / GEM / TEXTWIND.D < prev    next >
Encoding:
Modula Definition  |  1991-07-16  |  25.2 KB  |  586 lines
  1. DEFINITION MODULE TextWindows;
  2.  
  3.  
  4. (*  System              : Megamax Modula-2 (MOS 2.0)
  5.  *  Autor & Copyright   : Manuel Chakravarty
  6.  *  Vertrieb            : Application Systems Heidelberg
  7.  *  Version             : 2.9
  8.  *)
  9.  
  10.  
  11. (*      Diese Modul bietet die Möglichkeit zur einfachen, aber dennoch
  12.  *      komfortablen Nutzung der vom AES bereitgestellten Fensterroutinen.
  13.  *      Jede aus dem Modul 'Terminal' bekannte Routine ist auch in diesem
  14.  *      Modul zu finden. Dadurch ist es ohne großen Aufwand möglich die
  15.  *      Ein- und Ausgaben eines, ursprünglich für den TOS-Bildschirm kon-
  16.  *      zipierten Programmes auf die Textfenster umzulenken. Von dieser
  17.  *      Möglichkeit macht auch das MOS einige Male Gebrauch.
  18.  *      Des weiteren erlaubt die Prozedur 'DetectChar', daß der Anwender
  19.  *      innerhalb eines Textfensters, mit Hilfe der Maus, ein beliebiges
  20.  *      Zeichen auswählt.
  21.  *
  22.  *      Die Fensterverwaltung ist weitgehend automatisch, daß heißt bei
  23.  *      Änderungen der Position, Größe oder des sichtbaren Ausschnitts
  24.  *      des Fensters wird das Anwenderprogramm nicht benötigt, dies wird
  25.  *      genauso wie das eventuelle Neuzeichnen von Teile des Fensterin-
  26.  *      halts selbständig von 'TextWindows' erledigt.
  27.  *      Lediglich bei komplexeren Aktionen, wie dem Auswählen von Zeichen
  28.  *      innerhalb des Fensters mit der Maus, oder dem mehr oder weniger
  29.  *      beliebigen Schließen des Fensters, durch das Schließsymbol, muß
  30.  *      die Anwendung dem Modul ein wenig unter die Arme greifen.
  31.  *
  32.  *      Außerdem wird von den Ausgaberoutinen des Moduls auch der VT-52
  33.  *      Emulator unterstützt. Dieser kann aber auch unterdrückt werden.
  34.  *
  35.  *      Erweiterung des VT-52-Emulators:
  36.  *
  37.  *              ESC+CTRL-E  -- Schaltet 'EnhancedOutput' an
  38.  *              ESC+CTRL-F  -- Schaltet 'EnhancedOutput' aus
  39.  *              ESC+CTRL-P  -- Flush
  40.  *
  41.  *          (siehe Funktionen 'EnhancedOutput' und 'FlushPipe')
  42.  *
  43.  *
  44.  *      Bei jeder Eingabe, zum Beispiel mittels 'ReadString', kann der
  45.  *      Anwender auch die Fensterelemente manipulieren und damit bei-
  46.  *      spielsweise die Fenstergröße oder den sichtbaren Ausschnitt
  47.  *      ändern. Falls allerdings längere Zeit keine Eingabe stattfindet
  48.  *      und trotzdem eine Bedienung der Fensterelemente gewünscht ist,
  49.  *      kann dies mit wiederholten Aufrufen von 'EventHandler.FlushEvents'
  50.  *      ermöglicht werden.
  51.  *)
  52.  
  53.  
  54. FROM MOSGlobals IMPORT Key;
  55.  
  56. FROM GEMGlobals IMPORT GemChar, SpecialKeySet;
  57.  
  58. FROM GrafBase   IMPORT Point, Rectangle;
  59.  
  60.  
  61. TYPE    Window;
  62.         
  63.         (*  Legt das Verhalten eines Fensters bei einer Ausgabe fest.
  64.          *
  65.          *    'noForce'     -- Kein besonderes Verhalten.
  66.          *    'forceTop'    -- Das Fenster wird bei jeder Ausgabe zum ober-
  67.          *                     sten Fenster gemacht.
  68.          *    'forceLine'   -- Das Fenster wird zum obersten Fenster und zu-
  69.          *                     sätzlich in der Vertikalen derart gescrollt,
  70.          *                     daß die Zeile in der sich der Cursor befindet
  71.          *                     sichtbar ist.
  72.          *    'forceCursor' -- Das Fenster wird zum obersten Fesnter und
  73.          *                     außerdem in der Vertikalen und Horizontalen
  74.          *                     derart gescrollt, daß der Cursor sichtbar
  75.          *                     ist.
  76.          *)
  77.         ForceMode       = (noForce, forceTop, forceLine, forceCursor);
  78.         
  79.         (*  Legt das Aussehen und die Möglichkeiten eines Fensters fest.
  80.          *
  81.          *  'movable'   -- Das Fenster kann vom Anwender verschoben
  82.          *                 werden.
  83.          *  'closable'  -- Das Fenster besitzt ein Schließfeld.
  84.          *  'dynamic'   -- Das Fenster kann sowohl vom Anwender gescrollt,
  85.          *                 als auch in der Größe verändert werden.
  86.          *  'titled'    -- Das Fenster besitzt eine Titelzeile.
  87.          *)
  88.         WindowQuality   = (movable, closable, dynamic, titled);
  89.         WQualitySet     = SET OF WindowQuality;
  90.         
  91.         (*  Legt fest ob ein Fenster bei seiner Erzeugung sofort geöffnet
  92.          *  wird.
  93.          *
  94.          *  'noHideWdw' -- Das Fenster wird geöffnet.
  95.          *  'hideWdw'   -- Das Fenster wird nicht geöffnet.
  96.          *)
  97.         ShowMode        = (noHideWdw, hideWdw);
  98.  
  99.  
  100. CONST    (*  Bezeichnet eine unbesetzte Fensterkennung.
  101.           *)
  102.          NoWind          = Window (NIL);
  103.  
  104.         CenterWindow    = -1;
  105.         MaxWindow       = -1;
  106.  
  107.  
  108.                 (*  Fensterverwaltungsprozeduren  *)
  109.                 (*  ============================  *)
  110.  
  111. PROCEDURE Open (VAR hdl            : Window;
  112.                     columns, rows  : CARDINAL;
  113.                     qualitys       : WQualitySet;
  114.                     mode           : ShowMode;
  115.                     force          : ForceMode;
  116.                     wName          : ARRAY OF CHAR;
  117.                     colOrg, rowOrg,
  118.                     wOrg, hOrg     : INTEGER;
  119.                 VAR success        : BOOLEAN);
  120.                
  121.         (*  Diese relativ komplexe Routine erfüllt im wesentlichen nur einen
  122.          *  Zweck, sie erzeugt ein neues Fenster. Da hierbei schon der Grund-
  123.          *  stein für das spätere Verhalten des Fensters gelegt wird, müssen
  124.          *  einige Parameter übergeben werden.
  125.          *  'columns' und 'rows' bestimmen die Anzahl der für dieses Fen-
  126.          *  ster verwendeten Spalten und Zeilen. Die einzige Beschränkung
  127.          *  für diese zwei Werte ist, daß ihr Produkt nicht in die Nähe von
  128.          *  'MaxCard' kommen darf.
  129.          *  'qualitys' gliedert sich wie folgt:
  130.          *
  131.          *  'movable'  -- Der Anwender darf die Position des Fensters auf
  132.          *                dem Bildschirm mit der Maus verändern
  133.          *  'closable' -- In der linken, oberen Ecke des Fensters erscheint
  134.          *                ein Symbol, das es dem Anwender erlauben soll das
  135.          *                Fenster zu schließen. Nach dem Anklicken des Sym-
  136.          *                bols gilt: 'WasClosed(hdl) = TRUE' (Siehe Unten)
  137.          *                Achtung: Für das eigentliche Schließen des Fen-
  138.          *                         sters muß das Anwendungsprogramm sorgen.
  139.          *  'dynamic'  -- Ein Fenster mit diesem Feature kann vom Anwender
  140.          *                zum einen in seiner Größe verändert werden, zum
  141.          *                anderen kann er mit den Fensterschiebern wählen
  142.          *                welchen Ausschnitt des Fensterinhaltes er be-
  143.          *                trachten will.
  144.          *  'titled'   -- Solch ein Fenster besitzt einen Fensternamen.
  145.          *
  146.          *  Die einzelnen Elemente sind beliebig kombinierbar.
  147.          *
  148.          *  'show' bestimmt ob das Fenster sofort auf dem Bildschirm sicht-
  149.          *  bar gemacht werden soll.
  150.          *  'force' bestimmt auf welche Art und Weise das Fenster bei Ausga-
  151.          *  ben reagieren soll.
  152.          *  'wName' ist nichts weiter als der Fenstername oder -titel, er
  153.          *  erscheint in einem Balken über dem Arbeitsbereich des Fensters.
  154.          *  Die Zeichenkette wird nur berücksichtigt, falls 'titled' Element
  155.          *  von 'qualitys' ist.
  156.          *  'colOrg' und 'rowOrg' bestimmen die Startposition, 'wOrg' und
  157.          *  'hOrg' die Startgröße des Fensters. Diese Angaben werden alle
  158.          *  in Zeichenkoordinaten (nicht Pixelkoordinaten) gemacht. Ist
  159.          *  eine der Positionen 'CenterWdw', so wird das Fenster in dieser
  160.          *  Achse auf dem Bildschirm mittig dargestellt. Ist eine Größenangabe
  161.          *  gleich 'MaxWdw', so wird dort die Maximalgröße gewählt.
  162.          *
  163.          *  Ist 'success = TRUE', so konnte das Fenster korrekt erzeugt
  164.          *  werden und 'hdl' enthält die Fensterkennung.
  165.          *
  166.          *  Bei jedem 'Open' erhält der Mauszeiger die Pfeilform.
  167.          *
  168.          *  'columns * rows' darf 65535 nicht überschreiten, sonst
  169.          *  wird 'success = FALSE' geliefert.
  170.          *
  171.          *  Bei sehr kleinen Fenster, die Slider besitzen, kann es passieren,
  172.          *  daß der Arbeitsbereich des Fensters größer ist als der Textpuffer.
  173.          *  Das Modul benutzt dann nur den linken oberen Bereich.
  174.          *)
  175.          
  176. PROCEDURE SysOpen (VAR hdl           : Window;
  177.                        columns, rows : CARDINAL;
  178.                        qualitys      : WQualitySet;
  179.                        mode          : ShowMode;
  180.                        force         : ForceMode;
  181.                        wName         : ARRAY OF CHAR;
  182.                        colOrg, rowOrg: INTEGER;
  183.                        wOrg, hOrg    : INTEGER;
  184.                    VAR success       : BOOLEAN);
  185.                    
  186.         (*  Entspricht 'Open' vollständig.
  187.          *  Diese Routine ist für das Fensteröffnen durch Systemroutinen,
  188.          *  oder residente Routine gedacht.
  189.          *)
  190.                   
  191. PROCEDURE ReSpecify (hdl           : Window;
  192.                      columns, rows : CARDINAL; wName : ARRAY OF CHAR;
  193.                      VAR success   : BOOLEAN);
  194.                      
  195.         (*  Mit dieser Prozedur können sowohl der Name als auch die Ausmaße
  196.          *  eines Fensters oder der Zeichensatz (Font) geändert werden.
  197.          *  Mit den Ausmaßen ist in diesem Fall nicht die Größe des
  198.          *  sichtbaren Fensters, sondern die des Textpuffers, von dem man
  199.          *  in der Regel nur einen Ausschnitt sieht, gemeint.
  200.          *  'wName', das den Fensternamen enthält, wird nur berücksichtigt,
  201.          *  falls das Fenster beim öffnen die 'WindowQuality' 'title'
  202.          *  erhalten hat.
  203.          *  Wird die Puffergröße geändert, so geht dabei der aktuelle Inhalt
  204.          *  des Fensters verloren.
  205.          *
  206.          *  Um den Font zu setzen, ist für "columns" eine Null zu übergeben.
  207.          *  'rows' bestimmt dann die Zeichenhöhe in Punkt (s. SetPtsTHeight)
  208.          *  und 'wName' bestimmt den Namen des Fonts.
  209.          *  Wird 'NoWind' in 'hdl' übergeben, wird der Default-Font bestimmt,
  210.          *  der beim Öffnen (Open()) aller neuen Fenster benutzt wird.
  211.          *  Ansonsten wird der aktuelle Font des anggebenen Fensters ersetzt.
  212.          *)
  213.                      
  214. PROCEDURE Close (VAR hdl: Window);
  215.  
  216.         (*  Mit dieser Routine wird ein Fenster geschlossen, genauer ge-
  217.          *  löscht. Das bedeutet, daß es vom Bildschirm genommen und seine
  218.          *  Fensterkennung freigegeben wird.
  219.          *  Wird die Kennung danach noch einmal benutzt, so lößt dies einen
  220.          *  Laufzeitfehler aus.
  221.          *)
  222.  
  223. PROCEDURE Hide (hdl: Window);
  224.  
  225.         (*  Das Fenster wird unsichtbar, ist aber nach wie vor im Speicher
  226.          *  vorhanden und sowohl Ausgabe- als auch Eingabeoperationen kön-
  227.          *  nen getätigt werden. Bei Letzterem kann der Anwender aber nicht
  228.          *  kontollieren, was er tut.
  229.          *)
  230.  
  231. PROCEDURE Show (hdl: Window);
  232.  
  233.         (*  Das Fenster wird, falls es versteckt war, wieder sichtbar
  234.          *  gemacht.
  235.          *)
  236.  
  237. PROCEDURE GetPosAndSize (hdl: Window; VAR col, row, w, h: INTEGER);
  238.  
  239.         (*  Erfragt sowohl Position, als auch Größe des Fensters mit
  240.          *  der Kennung 'hdl'. Die Angaben werden in Zeichenkoordina-
  241.          *  ten gemacht.
  242.          *)
  243.  
  244. PROCEDURE SetPosAndSize (hdl: Window; col, row, w, h: INTEGER);
  245.  
  246.         (*  Setzt Position und Größe des Fensters.
  247.          *
  248.          *  Die Angaben müssen in Zeichenkoordinaten gemacht werden.
  249.          *)
  250.  
  251. PROCEDURE IsTop (hdl: Window): BOOLEAN;
  252.  
  253.         (*  Liefert den Wert 'TRUE', falls das angegebene Fenster das
  254.          *  Oberste aller Fenster ist.
  255.          *)
  256.  
  257. PROCEDURE PutOnTop (hdl: Window);
  258.  
  259.         (*  Macht das Fenster zum Obersten und damit auch zum aktiven
  260.          *  Fenster.
  261.          *)
  262.  
  263. PROCEDURE WasClosed (hdl: Window): BOOLEAN;
  264.  
  265.         (*  Falls das Fenster die 'WindowQuality' 'closable' besitzt und
  266.          *  der Anwender das Schließsymbol des Fensters angeklickt hat,
  267.          *  so ist das Ergebnis 'TRUE'.
  268.          *
  269.          *  Hinweis: Durch das Anklicken verschwindet das Fenster noch
  270.          *           nicht vom Bildschirm, dazu muß erst die Prozedur
  271.          *           'Hide' oder 'Close' aufgerufen werden.
  272.          *)
  273.  
  274.  
  275.                         (*  Allgemeine Ein-/Ausgabeprozeduren  *)
  276.                         (*  =================================  *)
  277.  
  278. PROCEDURE Write (hdl: Window; ch: CHAR);
  279.  
  280.         (*  Das Zeichen 'ch' wird im Fenster, das die Kennung 'hdl' besitzt,
  281.          *  an der Cursorposition ausgegeben.
  282.          *)
  283.  
  284. PROCEDURE WriteString (hdl: Window; REF str: ARRAY OF CHAR);
  285.  
  286.         (*  Die komplette Zeichenkette 'str' wird in das Fenster mit der
  287.          *  Kennung 'hdl' ausgegeben.
  288.          *)
  289.  
  290. PROCEDURE WriteLn (hdl: Window);
  291.  
  292.         (*  Schickt einen Zeilenvorschub- und einen Wagenrücklaufbefehl
  293.          *  an das angegebene Fenster (ASCII 10 und 13).
  294.          *)
  295.  
  296. PROCEDURE WritePg (hdl: Window);
  297.  
  298.         (*  Der Inhalt des Fensters mit der Kennung 'hdl' wird gelöscht.
  299.          *  Der Cursor steht danach in der linken oberen Ecke.
  300.          *)
  301.  
  302. PROCEDURE GotoXY (hdl: Window; column, row: CARDINAL);
  303.  
  304.         (*  Der Textcursor des Fensters 'hdl' wird in die Spalte 'column'
  305.          *  und die Zeile 'row' positioniert.
  306.          *)
  307.  
  308.  
  309. PROCEDURE Read (hdl: Window; VAR ch: CHAR);
  310.  
  311.         (*  Es wird ein Zeichen 'ch' gelesen, dabei wird der Cursor im
  312.          *  Fenster 'hdl' sichtbar gemacht und das Zeichen wird in diesem
  313.          *  Fenster an der Cursorposition dargestellt.
  314.          *  Wurden vorher Ausgaben durch den Enhanced-Modus unterdrückt,
  315.          *  so werden sie hier automatisch nachgeholt.
  316.          *)
  317.  
  318. PROCEDURE ReadLine (hdl: Window; VAR str: ARRAY OF CHAR);
  319.  
  320.         (*  Es wird eine Zeichenkette, von der Tastatur gelesen. Das
  321.          *  Echo wird in dem Fenster mit der Kennung 'hdl' ausgegeben,
  322.          *  außerdem läßt sich die Zeichenkette editieren.
  323.          *  Nachdem ein <Return> die Eingabe beendet hat, wird der
  324.          *  Cursor an das Ende der eingegebene Zeichenkette gestellt.
  325.          *  Abbruch möglich mit Undo-Taste - dann wird ein Leerstring
  326.          *  in 'str' geliefert und 'Done' liefert FALSE.
  327.          *  Es können nur soviele Zeichen eingegeben werden, wie 'str'
  328.          *  fassen kann.
  329.          *  Ist der Modus 'writeCtrl' (s. Funktion 'SetCtrlMode') aktiv,
  330.          *  können auch Control-Zeichen sichtbar eingegeben werden.
  331.          *)
  332.  
  333. PROCEDURE EditLine (hdl: Window; VAR str: ARRAY OF CHAR);
  334.  
  335.         (*  Wie ReadLine, jedoch muß 'str' schon beim Aufruf einen String
  336.          *  enthalten, der dann angezeigt und editiert werden kann.
  337.          *)
  338.  
  339. PROCEDURE ReadToken (hdl: Window; VAR str: ARRAY OF CHAR);
  340.  
  341.         (*  Wie ReadLine, jedoch kann nur ein Wort ("Token") eingeben werden:
  342.          *  Führende Leerzeichen (und Control-Zeichen) werden ignoriert,
  343.          *  nach Eingabe eines güligen Zeichens wird beim nächsten Leer- oder
  344.          *  Control-Zeichen die Eingabe beendet.
  345.          *  Das Terminierungszeichen kann durch Aufrufe von
  346.          *   'UndoRead' und 'GetChar' ermittelt werden.
  347.          *)
  348.  
  349. PROCEDURE ReadString (hdl: Window; VAR str: ARRAY OF CHAR);
  350.  
  351.         (*  Identisch mit 'ReadLine'.
  352.          *)
  353.  
  354. PROCEDURE Done (hdl: Window): BOOLEAN;
  355.  
  356.       (*  Liefert FALSE nach Aufrufen der String-Eingabefunktionen (Read...,
  357.        *  Edit...), wenn Undo gedrückt wurde.
  358.        *  Hat keine Wirkung bei Einzel-Eingaben, wie Read, BusyRead, usw.
  359.        *)
  360.  
  361.  
  362. PROCEDURE AbortRead (hdl: Window);
  363.  
  364.         (*  Diese Funktion kann in "WatchDog"-Routinen (s. EventHandler)
  365.          *  aufgerufen werden, um die evtl. zu der Zeit auf Eingaben
  366.          *  wartende Read-Funktion (Read, ReadString, EditLine, usw.)
  367.          *  zum Abbruch zu veranlassen. Wird dann der aufgetretene Event,
  368.          *  über den der WatchDog wachte, durchgelassen, kann die Read-
  369.          *  Funktion zurückkehren - Done ist dann FALSE, ein leerer
  370.          *  String (bzw 0C bei Read) wird zurückgegeben, so, als wenn
  371.          *  der Anwender die Undo-Taste gedrückt hätte.
  372.          *
  373.          *  Zur Anwendung kommt diese Funktion in Accessories, die
  374.          *  die Read-Funktionen von TextWindows verwenden. Denn es ist
  375.          *  dann möglich, während z.B. ReadString auf die Eingabe wartet,
  376.          *  daß der Anwender ein Fenster der Hauptanwendung anklick und
  377.          *  dann das Hauptprogramm zum Beenden veranlaßt. Dann schließt
  378.          *  das GEM automatisch das Fenster des Accessories, sodaß dessen
  379.          *  Read-Eingabe nicht mehr abgeschlossen werden kann. Hier muß
  380.          *  deshalb ein WatchDog vom ACC installiert sein, der darauf
  381.          *  achtet, ob ein Message-Event an das ACC gesendet wird, wonach
  382.          *  es nun seine Fenster zu schließen hat. In diesem Fall muß dann
  383.          *  AbortRead auf das Fenster der laufenden Eingabe angewendet
  384.          *  werden.
  385.          *
  386.          *  Ist das Fenster 'hdl' nicht offen oder findet z.Zt. keine
  387.          *  Eingabe darin statt, wird der Aufruf ignoriert.
  388.          *)
  389.  
  390.  
  391. (*      Die folgenden Routinen stellen reine Eingabeoperationen dar,
  392.  *      sie verändern den Bildschirminhalt nicht. Deshalb muß auch keine
  393.  *      Fensterkennung angegeben werden.
  394.  *)
  395.  
  396. PROCEDURE UndoRead;
  397.  
  398.         (*  (Auch "ReadAgain" in anderen Dialekten)
  399.          *  Das zuletzt gelesene Zeichen wird bei der nächsten Abfrage
  400.          *  nochmal geliefert.
  401.          *)
  402.  
  403. PROCEDURE KeyPressed (): BOOLEAN;
  404.  
  405.         (*  Liefert diese Funktion den Wert 'TRUE', so wurde eine Taste
  406.          *  gedrückt.
  407.          *)
  408.  
  409. PROCEDURE CondRead (VAR ch: CHAR; VAR success: BOOLEAN);
  410.  
  411.         (*  Falls eine Taste gerückt wurde, so wird diese in 'ch' gelesen.
  412.          *  Ist 'success = TRUE', so ist der Wert von 'ch' gültig.
  413.          *)
  414.  
  415. PROCEDURE BusyRead (VAR ch: CHAR);
  416.  
  417.         (*  Falls eine Taste gerückt wurde, so wird diese in 'ch' gelesen,
  418.          *  sonst kehrt die Routine sofort zurück und liefert 0C. Kein Echo.
  419.          *)
  420.  
  421. PROCEDURE FlushKbd;
  422.  
  423.         (*  Löscht den Tastaturpuffer.
  424.          *)
  425.  
  426. PROCEDURE GetChar (VAR ch: CHAR);
  427.  
  428.         (*  Wartet bis eine Taste gedrückt wird und liefert deren Wert.
  429.          *  Kein Echo.
  430.          *)
  431.  
  432. PROCEDURE GetGemChar (VAR ch: GemChar; VAR specials: SpecialKeySet);
  433. PROCEDURE GetKey (VAR k: Key);
  434.  
  435.         (*  Warten auf einen Tastendruck und liefert ASCII- und Scancode,
  436.          *  sowie die Sondertasten.
  437.          *)
  438.  
  439.  
  440.                 (*  Spezielle Textfensterprozeduren  *)
  441.                 (*  ===============================  *)
  442.  
  443. PROCEDURE GetPos (hdl: Window; VAR column, row: CARDINAL);
  444.  
  445.         (*  Ermittelt die Position des Cursors im Fenster mit der Kennung
  446.          *  'hdl'. 'column' enthält die Spalte und 'row' die Zeile.
  447.          *)
  448.  
  449. TYPE    CtrlMode        = (interpretCtrl, writeCtrl);
  450.  
  451. PROCEDURE SetCtrlMode (hdl: Window; mode: CtrlMode);
  452.  
  453.         (*  Hiermit stellt man den Modus für die Ausgabe von Kontrollzeichen
  454.          *  in das Fenster mit der Kennung 'hdl' ein. Dabei gilt:
  455.          *
  456.          *  'interpretCtrl' -- Die ASCII-Zeichen mit einer Ordinalzahl klei-
  457.          *                     ner 32 werden als Steuerzeichen interpretiert.
  458.          *                     Dies ist der Standardwert.
  459.          *  'writeCtrl'     -- Zu jedem ASCII-Wert wird das im Zeichensatz
  460.          *                     zugehörige Zeichen ausgegeben.
  461.          *)
  462.  
  463. PROCEDURE GetCtrlMode (hdl: Window; VAR mode: CtrlMode);
  464.  
  465.         (*  Erfragt den mit 'SetCtrlMode' gesetzten Wert.
  466.          *)
  467.  
  468.  
  469. TYPE    EchoMode        = (fullEcho, restrictedEcho, noEcho);
  470.  
  471. PROCEDURE SetEchoMode (hdl: Window; mode: EchoMode);
  472.  
  473.         (*  Hier mit wird die Art und Weise des Echos bei Eingaberoutinen
  474.          *  festgelegt. 'mode' kann folgende Werte annehmen:
  475.          *
  476.          *  'fullEcho'       -- Zu jedem eingegebenen Zeichen wird ein Echo
  477.          *                      ausgegeben. Also auch bei Steuerzeichen.
  478.          *  'restrictedEcho' -- Bei jedem Zeichen, dessen Ordinalzahl größer
  479.          *                      als 32 ist, wird ein Echo ausgegeben.
  480.          *                      Dies ist der Standardwert.
  481.          *  'noEcho'         -- Es wird grundsätzlich kein Echo ausgegege-
  482.          *                      ben.
  483.          *)
  484.  
  485. PROCEDURE GetEchoMode (hdl: Window; VAR mode: EchoMode);
  486.  
  487.         (*  Diese Funktion liefert den mit 'SetEchoMode' eingestellten Wert.
  488.          *)
  489.  
  490.  
  491. PROCEDURE EnhancedOutput (hdl: Window; start: BOOLEAN);
  492.  
  493.         (*  Diese Routine ermöglicht es, größere Zeichenmengen beschleunigt
  494.          *  auszugeben.
  495.          *  Dazu muß diese Prozedur vor der Ausgabe mit 'start = TRUE'
  496.          *  und nach Beendigung der Ausgabe mit 'FALSE' aufgerufen werden.
  497.          *  Während dieser Zeit ist der Anwender nicht in der Lage Fenster-
  498.          *  elemente, oder eine eventuell vorhandene Menuzeile zu manipu-
  499.          *  lieren. Auch werden im ungünstigsten Fall erst zum Ende die
  500.          *  bis dahin ausgegebenen Zeichen angezeigt.
  501.          *  Wird eine Routine aufgerufen, die auf eine Eingabe wartet
  502.          *  (Read, ReadString, ReadLine, ReadToken, EditLine, jedoch
  503.          *  nicht CondRead, BusyRead), dann wird automatisch 'FlushPipe'
  504.          *  (s.u.) aufgerufen, dieser spezielle 'Enhanced'- Ausgabemodus
  505.          *  bleibt aber intakt.
  506.          *
  507.          *  Ein Programm kann auch einmal zu Beginn den "Enhanced"-Modus
  508.          *  aktivieren und dann nicht mehr abschalten. Es bleibt dann
  509.          *  immer aktiv, bei Eingaben oder durch 'FlushPipe' kann trotzdem
  510.          *  alles Ausgegebene zwischendurch sichtbar werden.
  511.          *
  512.          *  Die Ausgabe von ESC und Ctrl-E/-F haben dieselbe Wirkung
  513.          *)
  514.  
  515. PROCEDURE FlushPipe (hdl: Window);
  516.  
  517.         (*  Erzwingt die Ausgabe alle Zeichen, die bisher gepuffert wurden,
  518.          *  der Pufferungs-Modus ("Enhanced") bleibt weiterhin aktiv.
  519.          *
  520.          *  Ausgabe von ESC & Ctrl-P hat die gleiche Wirkung.
  521.          *)
  522.  
  523.  
  524. TYPE    DetectMode      = (takePnt, requestPnt);
  525.         DetectResult    = (foundNothing, foundWindow, foundChar);
  526.  
  527. PROCEDURE DetectChar (REF targets: ARRAY OF Window;
  528.                           noTrg  : CARDINAL;
  529.                           mode   : DetectMode;
  530.                       VAR p      : Point;
  531.                       VAR hdl    : Window;
  532.                       VAR column,
  533.                           row    : CARDINAL;
  534.                       VAR box    : Rectangle;
  535.                       VAR result : DetectResult);
  536.                     
  537.         (*  Diese Routine erlaubt es beliebige Bildschirmpositionen darauf-
  538.          *  hin zu untersuchen, ob sich dort ein Fenster oder sogar ein Zei-
  539.          *  chen befindet.
  540.          *  In 'targets' werden die Kennungen aller Fenster abgelegt, die
  541.          *  untersucht werden sollen. 'noTrg' gibt an, wieviele Elemente
  542.          *  in 'targets' enthalten sind. Ist 'noTrg' gleich Null, so werden
  543.          *  alle Feldelemente ausgewertet.
  544.          *  'mode' bestimmt, ob die Anwendung der Routine einen Punkt in 'p'
  545.          *  übergibt, der ausgewertet werden soll ('mode = takePnt') oder
  546.          *  ob die Prozedur selber auf einen Druck der linken Maustaste
  547.          *  wartet und die Position des Mauszeigers für den Suchvorgang be-
  548.          *  nutzt und anschließend in 'p' zurückliefert ('requestPnt').
  549.          *  Das Ergebenis ('result') unterscheidet drei Möglichkeiten:
  550.          *
  551.          *  'foundNothing' -- An der Stelle 'p' befindet sich "nichts".
  552.          *  'foundWindow'  -- Es befindet sich dort ein beliebiges Fenster.
  553.          *                    Dies Fenster muß nicht in 'targets' enthalten
  554.          *                    sein.
  555.          *  'foundChar'    -- An dem Ort 'p' befindet sich erstens ein Fen-
  556.          *                    ster aus 'targets' und zweitens Zeichen, das
  557.          *                    in dem Fenster steht.
  558.          *
  559.          *  Befindet sich der Stelle 'p' ein Fenster, das in 'targets' aufge-
  560.          *  führt ist, gleichgültig ob Fensterinneres oder -außenbereich, so
  561.          *  liefert 'hdl' die Kennung dieses Fensters, sonst ist 'hdl =
  562.          *  NoWind'. Ist 'result = foundChar', so liefert 'column' die Spal-
  563.          *  te und 'row' die Zeile des gefundenen Zeichens, innerhalb des
  564.          *  Fensters 'hdl'. Außerdem enthält 'box' die, das Zeichen umge-
  565.          *  bende Zeichenzelle.
  566.          *)
  567.  
  568. PROCEDURE ReadTextBuffer (    wdw     : Window;
  569.                               startCol,
  570.                               startRow,
  571.                               amount  : CARDINAL;
  572.                           VAR buffer  : ARRAY OF CHAR;
  573.                           VAR nextCol,
  574.                               nextRow : CARDINAL);
  575.  
  576.         (*  Ließt den Puffer ab 'startCol/startRow' aus und schreibt ihn
  577.          *  in 'buffer'. Sind 'amount' Zeichen gelesen, oder ist das Puffer-
  578.          *  ende erreicht, ohne das 'buffer' zu Ende ist, so wird ein 0C
  579.          *  geschrieben. Die Zeilenenden sind durch CR+LF gekennzeichnet,
  580.          *  wobei white spaces unterdrückt werden. Ein Wechsel von inverser
  581.          *  auf normale Darstellungsart und umgekehrt wird durch die VT52
  582.          *  ESC-Sequenzen angezeigt.
  583.          *)
  584.          
  585.          
  586. END TextWindows.